home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / DISK / CBHD502 / SRC / M2 / SCSI.M < prev    next >
Encoding:
Modula Implementation  |  1996-12-09  |  8.5 KB  |  304 lines
  1. IMPLEMENTATION MODULE Scsi;
  2. (****************************************************************************
  3.  *
  4.  * SCSI-Zugriffe nach SCSI-2
  5.  *
  6.  * $Source: /dev/e/hm2/lib/se\RCS\SCSI.M,v $
  7.  *
  8.  * $Revision: 1.2 $
  9.  *
  10.  * $Author: Steffen_Engel $
  11.  *
  12.  * $Date: 1996/02/14 00:04:08 $
  13.  *
  14.  * $State: Exp $
  15.  *
  16.  *****************************************************************************
  17.  * History:
  18.  *
  19.  * $Log: SCSI.M,v $
  20.  * Revision 1.2  1996/02/14  00:04:08  Steffen_Engel
  21.  * Korrektur bei Maskierung in SetCmd6: Maske 1F mu₧ Modulo 20 tragen.
  22.  *
  23.  * Revision 1.1  1996/02/03  19:33:48  S_Engel
  24.  * Initial revision
  25.  *
  26.  *****************************************************************************
  27.  * altes Modul: SCSI2.M
  28.  *
  29.  * Revision 1.5  1995/10/30  17:44:48  S_Engel
  30.  * *** empty log message ***
  31.  *
  32.  * Revision 1.4  1995/04/13  13:46:56  S_Engel
  33.  * Simple Senseauswertung mit GetError
  34.  *
  35.  * Revision 1.3  1995/02/10  12:38:10  S_Engel
  36.  * Anpassungen an aktuellen SCSI-Driver
  37.  *
  38.  * Revision 1.2  1995/02/07  23:59:40  S_Engel
  39.  * Umstellung auf handleorientierte SCSI-Routinen
  40.  *
  41.  * Revision 1.1  1995/01/01  19:14:46  S_Engel
  42.  * Initial revision
  43.  *
  44.  *
  45.  ****************************************************************************)
  46.  
  47.  
  48. FROM SYSTEM   (* Type  *) IMPORT BYTE, ADDRESS,
  49.               (* Proc  *) ADR, TSIZE;
  50.  
  51. IMPORT SYSTEM;
  52.  
  53. FROM Portab IMPORT UChar, Char;
  54.  
  55. IMPORT ScsiIO;
  56.  
  57.   FROM SYSTEM  IMPORT CODE;
  58.   (* String für WHAT - leider ein bi₧chen HM2-spezifisches *)
  59.   CONST What = '@(#) Scsi2 '
  60.                + CHR(SYSTEM.DATE DIV 1000000H DIV 10 + 48)
  61.                + CHR(SYSTEM.DATE DIV 1000000H MOD 10 + 48) + '.'
  62.                + CHR(SYSTEM.DATE DIV 10000H MOD 100H DIV 10 MOD 10 + 48)
  63.                + CHR(SYSTEM.DATE DIV 10000H MOD 100H MOD 10 + 48) + '.'
  64.                + CHR(SYSTEM.DATE MOD 10000H DIV 10 MOD 10 + 48)
  65.                + CHR(SYSTEM.DATE MOD 10000H MOD 10 + 48)
  66.                + '  (c) S. Engel';
  67.  
  68.  
  69. (*------ Deklarationsteil *)
  70.  
  71. VAR
  72.   Handle          : ScsiIO.tHandle; 
  73.  
  74. (*------ Hilfsunterprogramme *)
  75.  
  76. PROCEDURE SetCmd6(VAR CmdBlock : ARRAY OF SYSTEM.LOC;
  77.                   Cmd :SHORTCARD;BlockAdr:LONGCARD;
  78.                                    TransferLen:SHORTCARD) : tpCmd6;
  79.          
  80. BEGIN
  81.   WITH tpCmd6(ADR(CmdBlock))^ DO
  82.     Command := Cmd;
  83.     LunAdr  := BYTE(VAL(CHAR,LogicalUnit+
  84.               VAL(SHORTCARD,BlockAdr DIV 010000H) MOD 020H));
  85.     Adr     := VAL(SHORTCARD, BlockAdr MOD 010000H);
  86.     Len     := TransferLen MOD 0100H;
  87.     Flags   := BYTE(VAL(CHAR,0));
  88.   END;
  89.   RETURN ADR(CmdBlock);
  90. END SetCmd6;
  91.  
  92. PROCEDURE SetCmd10(VAR CmdBlock : ARRAY OF SYSTEM.LOC;
  93.                    Cmd :SHORTCARD;BlockAdr:LONGCARD;
  94.                                       TransferLen:SHORTCARD) : tpCmd10;
  95.          
  96. BEGIN
  97.   WITH tpCmd10(ADR(CmdBlock))^ DO
  98.     Command   := Cmd;
  99.     Lun       := BYTE(VAL(CHAR, LogicalUnit));
  100.     Adr       := BlockAdr;
  101.     Reserved  := 0;
  102.     LenHigh   := TransferLen DIV 100H;
  103.     LenLow    := TransferLen MOD 100H;
  104.     Flags     := BYTE(VAL(CHAR,0));
  105.   END;
  106.   RETURN ADR(CmdBlock);
  107. END SetCmd10;
  108.  
  109. PROCEDURE SetCmd12(VAR CmdBlock : ARRAY OF SYSTEM.LOC;
  110.                    Cmd : SHORTCARD; BlockAdr    : LONGCARD;
  111.                                     TransferLen : LONGCARD) : tpCmd12;
  112.          
  113. BEGIN
  114.   WITH tpCmd12(ADR(CmdBlock))^ DO
  115.     Command := Cmd;
  116.     Lun     := BYTE(VAL(CHAR,LogicalUnit));
  117.     Adr     := BlockAdr;
  118.     Len     := TransferLen;
  119.     Reserved:= BYTE(0);
  120.     Flags   := BYTE(0);
  121.   END;
  122.   RETURN ADR(CmdBlock);
  123. END SetCmd12;
  124.  
  125. PROCEDURE SetCmd(VAR ScsiCmd  : ARRAY OF SYSTEM.LOC;
  126.                  VAR CmdBlock : ARRAY OF SYSTEM.LOC;
  127.                      Buffer   : SYSTEM.ADDRESS;
  128.                      Len      : LONGCARD;
  129.                      TimeOut  : LONGCARD) : ScsiIO.tpSCSICmd;
  130. (*ScsiIO.In(SetCmd(SCmd, Cmd6, Buffer, TransLen, ScsiIO.DefTimeout)) = 0;*)
  131. VAR
  132.   pCmd : ScsiIO.tpSCSICmd;
  133.  
  134.   BEGIN
  135.     pCmd := ScsiIO.tpSCSICmd(ADR(ScsiCmd));
  136.  
  137.     pCmd^.handle := Handle;
  138.     pCmd^.Cmd    := SYSTEM.ADR(CmdBlock);
  139.     pCmd^.CmdLen := HIGH(CmdBlock) + 1;
  140.     pCmd^.Buffer := Buffer;
  141.     pCmd^.TransferLen := Len;
  142.     pCmd^.SenseBuffer := SYSTEM.ADR(ScsiIO.ReqBuff);
  143.     pCmd^.Timeout := TimeOut;
  144.     pCmd^.Flags := ScsiFlags;
  145.     RETURN SYSTEM.ADR(ScsiCmd);
  146.  
  147.   END SetCmd;
  148.  
  149.  
  150. PROCEDURE TestUnitReady() : BOOLEAN;
  151. VAR SCmd            : ScsiIO.tSCSICmd;
  152.  
  153. BEGIN
  154. (*  VOID(SetCmd6(Cmd6, 000H,0,0));*)
  155. (*  RETURN ScsiIO.In(SetCmd(SCmd, Cmd6, NIL, 0, ScsiIO.DefTimeout)) = 0;*)
  156.  
  157.   RETURN ScsiIO.In(SetCmd(SCmd, SetCmd6(Cmd6, 000H, 0, 0)^, NIL, 0, ScsiIO.DefTimeout)) = 0;
  158. END TestUnitReady;
  159.  
  160.  
  161. PROCEDURE Inquiry(Buffer : ADDRESS; Vital : BOOLEAN; Page : SHORTCARD; TransLen : SHORTCARD) : BOOLEAN;
  162. VAR SCmd            : ScsiIO.tSCSICmd;
  163.  
  164.   BEGIN
  165.     WITH Cmd6 DO
  166.       Command := 12H;
  167.       LunAdr  := BYTE(VAL(CHAR, LogicalUnit));
  168.       Adr := 0;
  169.       IF Vital
  170.       THEN
  171.         LunAdr  := BYTE(VAL(CHAR, LogicalUnit + 1));
  172.         Adr := Page * 100H;
  173.       END;
  174.       Len := TransLen;
  175.       Flags := BYTE(0);
  176.     END;
  177.     RETURN ScsiIO.In(SetCmd(SCmd, Cmd6, Buffer, TransLen, ScsiIO.DefTimeout)) = 0;
  178.   END Inquiry;
  179.  
  180.  
  181. PROCEDURE ModeSelect(SelectFlags  : tsSelectFlag;
  182.                         Buffer       : ADDRESS;
  183.                         ParmLen      : SHORTCARD) : BOOLEAN;
  184. VAR SCmd            : ScsiIO.tSCSICmd;
  185.  
  186. BEGIN
  187.   ParmLen := ParmLen
  188.              + TSIZE(tParmHead)       (* ParameterHeader                *)
  189.              + TSIZE(tBlockDesc);     (* Block-Deskriptor               *)
  190.  
  191.   WITH Cmd6 DO
  192.     Command := 015H;
  193.     LunAdr  := BYTE(VAL(CHAR,LogicalUnit+(VAL(SHORTCARD,CHAR(SelectFlags)) MOD 020H)));
  194.     Adr     := 0;
  195.     Len     := ParmLen;
  196.     Flags   := BYTE(0);
  197.   END;
  198.   RETURN ScsiIO.Out(SetCmd(SCmd, Cmd6, Buffer, ParmLen, ScsiIO.DefTimeout)) = 0;
  199. (*  RETURN ScsiIO.SendCmdDataOut(Cmd6, 6, Buffer, ParmLen);*)
  200. END ModeSelect;
  201.  
  202.  
  203. PROCEDURE ModeSense(PageCode       : SHORTCARD;
  204.                        PageControl    : tPC;
  205.                        Buffer         : ADDRESS;
  206.                        ParmLen        : SHORTCARD) : BOOLEAN;
  207. VAR SCmd            : ScsiIO.tSCSICmd;
  208.  
  209. BEGIN
  210.   ParmLen := ParmLen
  211.              + TSIZE(tParmHead)       (* ParameterHeader                *)
  212.              + TSIZE(tBlockDesc);     (* Block-Deskriptor               *)
  213.  
  214.   WITH Cmd6 DO
  215.     Command := 01AH;
  216.     LunAdr  := BYTE(VAL(CHAR,LogicalUnit));
  217.     Adr     := ((ORD(PageControl) * 64 + PageCode) MOD 0100H)*0100H;
  218.     Len     := ParmLen;
  219.     Flags   := BYTE(0);
  220.   END;
  221.   RETURN ScsiIO.In(SetCmd(SCmd, Cmd6, Buffer, ParmLen, ScsiIO.DefTimeout)) = 0;
  222. (*  RETURN ScsiIO.SendCmdDataIn(Cmd6, 6, Buffer, ParmLen);*)
  223. END ModeSense;
  224.  
  225.  
  226. PROCEDURE PreventMediaRemoval(Prevent:BOOLEAN) : BOOLEAN;
  227. VAR SCmd            : ScsiIO.tSCSICmd;
  228.  
  229. BEGIN
  230.   IF Prevent THEN
  231.     VOID(SetCmd6(Cmd6, 01EH,0,1));
  232.   ELSE
  233.     VOID(SetCmd6(Cmd6, 01EH,0,0));
  234.   END;
  235.   RETURN ScsiIO.In(SetCmd(SCmd, Cmd6, NIL, 0, ScsiIO.DefTimeout)) = 0;
  236. END PreventMediaRemoval;
  237.  
  238.  
  239. PROCEDURE GetError(reqbuff : ADDRESS) : ErrorType;
  240. TYPE tReq = POINTER TO ARRAY[0..17] OF UChar;
  241.  
  242.   BEGIN
  243.     CASE tReq(reqbuff)^[12] OF
  244.       |004H,
  245.        03AH: RETURN nomedia;
  246.       |028H: RETURN mediachange;
  247.       |029H: RETURN reset;
  248.  
  249.       ELSE
  250.           RETURN unknown;
  251.     END;
  252.   END GetError;
  253.  
  254.  
  255. (*-------------------------------------------------------------------------*)
  256. (*-                                                                       -*)
  257. (*- Allgemeine Tools                                                      -*)
  258. (*-                                                                       -*)
  259. (*-------------------------------------------------------------------------*)
  260.  
  261. PROCEDURE Wait(Ticks : LONGCARD);
  262. VAR Clock[04BAH], Time : LONGCARD;
  263.  
  264.   BEGIN
  265.     Time := Clock + Ticks;
  266.     WHILE Clock < Time DO
  267.     END;
  268.   END Wait;
  269.  
  270. PROCEDURE SetBlockSize(NewLen : LONGCARD);
  271.  
  272. BEGIN
  273.   BlockLen := NewLen;
  274. (*  MaxTransferLen:=VAL(SHORTCARD, ScsiIO.MaxDmaLen DIV VAL(LONGCARD, BlockLen));*)
  275. END SetBlockSize;
  276.  
  277. PROCEDURE GetBlockSize() : LONGCARD;
  278.  
  279. BEGIN
  280.   RETURN BlockLen;
  281. END GetBlockSize;
  282.  
  283.  
  284. (*$E+*)
  285. PROCEDURE MySetScsiUnit(handle : ScsiIO.tHandle; Lun: SHORTINT; MaxLen : LONGCARD);
  286.  
  287. BEGIN
  288. (*  ScsiIO.SetDmaScsiAdr(handle);*)
  289.   Handle := handle;
  290.   LogicalUnit:=VAL(SHORTCARD, Lun)*020H;
  291.   MaxDmaLen := MaxLen;
  292. END MySetScsiUnit;
  293. (*$E=*)
  294.  
  295.  
  296.  
  297.  
  298. BEGIN
  299.   LogicalUnit:=0;
  300.   SetBlockSize(ScsiIO.DmaBlockLen);
  301.   SetScsiUnit := MySetScsiUnit;
  302.   ScsiFlags := {};
  303. END Scsi.
  304.